package order

import (
	"fmt"
	"sync"
)

// 定义主题与实现

// Subject 主题接口
type Subject interface {
	Register(observer Observer)   // 注册观察者
	Unregister(observer Observer) // 注销观察者
	Notify(event *OrderEvent)     // 通知观察者
}

// OrderSubject 订单主题实现
type OrderSubject struct {
	observers map[string]Observer // 观察者列表
	mu        sync.Mutex          // 线程安全锁
}

// NewOrderSubject 创建订单主题
func NewOrderSubject() Subject {
	return &OrderSubject{
		observers: make(map[string]Observer),
	}
}

// Register 注册观察者
func (os *OrderSubject) Register(observer Observer) {
	os.mu.Lock()
	defer os.mu.Unlock()
	if _, ok := os.observers[observer.ID()]; ok {
		fmt.Printf("观察者 %s 已存在，无需重复注册\n", observer.ID())
		return
	}
	os.observers[observer.ID()] = observer
	fmt.Printf("观察者 %s 注册成功\n", observer.ID())
}

// Unregister 注销观察者
func (os *OrderSubject) Unregister(observer Observer) {
	os.mu.Lock()
	defer os.mu.Unlock()
	if _, ok := os.observers[observer.ID()]; !ok {
		fmt.Printf("观察者 %s 不存在，无需注销\n", observer.ID())
		return
	}
	delete(os.observers, observer.ID())
	fmt.Printf("观察者 %s 注销成功\n", observer.ID())
}

// Notify 通知观察者
func (os *OrderSubject) Notify(event *OrderEvent) {
	os.mu.Lock()
	defer os.mu.Unlock()
	if len(os.observers) == 0 {
		fmt.Printf("没有观察者，无需通知\n")
		return
	}
	// 并发通知下游
	var wg sync.WaitGroup

	for _, observer := range os.observers {
		wg.Add(1)
		go func(observer Observer) {
			defer wg.Done()
			defer func ()  {
				if err := recover(); err != nil {
					fmt.Printf("观察者 %s 通知失败: %v\n", observer.ID(), err)
				}
			}()
			observer.Update(event)
			fmt.Printf("观察者 %s 通知成功\n", observer.ID())
		}(observer)
	}
	wg.Wait()
}
